@file:Suppress("unused")

package com.example.base.tools.map

import androidx.lifecycle.Lifecycle
import androidx.lifecycle.LifecycleObserver
import androidx.lifecycle.LifecycleOwner
import androidx.lifecycle.OnLifecycleEvent
import com.example.base.BaseApp

/**
 * 定位组件
 */
object LocationTool {

   /* private val mLocationClient: LocationClient by lazy {
        LocationClient(BaseApp.context)
    }

    *//**  生命周期的监听类, 自动进行销毁操作  **//*
    private class LocationLifecycleListener : LifecycleObserver {
        @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
        fun destroyLocationServer() {
            stop()
        }
    }

    *//**
     * 定位客户端的定位参数设置
     *//*
    private val clientOption: LocationClientOption by lazy {
        val option = LocationClientOption()

        option.locationMode = LocationClientOption.LocationMode.Hight_Accuracy
        option.coorType = "bd09ll"                  // 返回的经纬度坐标类型
        option.scanSpan = 1000                      // 每隔一秒定位一次
        option.openGps = true                       // 使用混合定位模式时, 必须开启 GPS 定位
        option.setIsNeedAddress(true)               // 获取当前点的地址信息
        option.setIsNeedLocationDescribe(true)      // 获取位置描述信息
        option.setIsNeedLocationPoiList(true)       // 如果开发者需要获得周边POI信息，此处必须为true
        // option.isLocationNotify = true           // 设置是否当GPS有效时按照1S/1次频率输出GPS结果
        option.isIgnoreCacheException = true        // 不收集 Crash 信息
        option.wifiCacheTimeOut = 5 * 60 * 1000     // WI-FI 若超出有效期，会先重新扫描Wi-Fi，然后定位

        option
    }*/

    /**  纬度  **/
    var latitude: Double = 0.0
        private set

    /**  经度  **/
    var longitude: Double = 0.0
        private set

    /**  定位精度  **/
    var radius: Float = 0f
        private set

    /**  位置描述信息  **/
    var locationDescribe: String = ""
        private set

    /**  详细地址信息  **/
    var address: String = ""
        private set

    /**  国家  **/
    var country: String = ""
        private set

    /**  省份  **/
    var province: String = ""
        private set

    /**  城市  **/
    var city: String = ""
        private set

    /**  区县  **/
    var district: String = ""
        private set

    /**  街道信息  **/
    var street: String = ""
        private set

    /**
     * 位置变化监听
     */
   /* private val mLocationLisListener: BDAbstractLocationListener =
        object : BDAbstractLocationListener() {
            override fun onReceiveLocation(location: BDLocation?) {
                if (null == location) return

                latitude = location.latitude                   // 获取纬度
                longitude = location.longitude                 // 获取经度
                radius = location.radius                       // 获取定位精度

                locationDescribe = location.locationDescribe   // 位置描述信息
                address = location.addrStr                     // 获取详细地址信息
                country = location.country                     // 获取国家
                province = location.province                   // 获取省份
                city = location.city                           // 获取城市
                district = location.district                   // 获取区县
                street = location.street                       // 获取街道信息

                // Get poi info
                *//*val poi = location.poiList[0]
                val poiName = poi.name                  // 获取POI名称
                val poiTags = poi.tags                  // 获取POI类型
                val poiAddress = poi.addr               // 获取POI地址与周边POI信息
                Log.e("poiInfo", "poiName: $poiName, poiTags: $poiTags, poiAddr: $poiAddress")

                // Get PoiRegion
                val poiRegion = location.poiRegion
                val poiDerectionDesc = poiRegion.derectionDesc   // 获取PoiRegion位置关系
                val poiRegionName = poiRegion.name               // 获取PoiRegion名称
                val poiRegionTags = poiRegion.tags               // 获取PoiRegion类型
                Log.e("poiRegionInfo", "poiDerectionDesc: $poiDerectionDesc, poiRegionName: $poiRegionName, poiRegionTags: $poiRegionTags")*//*

                // 进行回调, 若只回调一次, 则自动进行停止操作
                onOrientListener(this@LocationTool)
                if (isOnce) stop()
            }
        }*/


    /**  是否只回调一次  **/
    private var isOnce = false
    /**  当定位成功时回调  **/
    private lateinit var onOrientListener: OnOrientListener

    /**
     * 初始化定位组件
     * @param lifecycleOwner Activity 或者 Fragment
     * @param callbackOnce 是否只回调一次, 默认否
     * @param listener 回调函数
     *//*
    @Synchronized
    fun init(
        lifecycleOwner: LifecycleOwner,
        callbackOnce: Boolean = false,
        listener: OnOrientListener = {}
    ) {
        synchronized(LocationTool::class.java) {
            isOnce = callbackOnce
            if (callbackOnce.not()) lifecycleOwner.lifecycle.addObserver(LocationLifecycleListener())
            onOrientListener = listener
            mLocationClient.locOption = clientOption
            mLocationClient.registerLocationListener(mLocationLisListener)
            mLocationClient.start()
        }
    }*/

    /**
     * 重制所有属性的值
     */
    private fun reset() {
        isOnce = false
        onOrientListener = {}

        latitude = 0.0
        longitude = 0.0
        radius = 0f

        locationDescribe = ""
        address = ""
        country = ""
        province = ""
        city = ""
        district = ""
        street = ""
    }

   /* *//**
     * 停止定位组件
     *//*
    fun stop() {
        if (street.isBlank()) return

        reset()
        mLocationClient.locOption = null
        mLocationClient.unRegisterLocationListener(mLocationLisListener)
        mLocationClient.stop()
    }
*/
}

/**  当定位成功时的回调类习惯定义  **/
private typealias OnOrientListener = (config: LocationTool) -> Unit